import java.util.Scanner;
// 这个题虽然不难，但是题感不够，脑残错误都能犯，还得练
public class Day32 {
    // 思路：中间年份挣的钱 + 开始年挣的钱 + 结束年挣的钱
    //  start      end
    // 2001-1-1  2001-5-1
    // 2001-1-1  2002-3-1
    // 2001-1-1  2003-4-1
    // 中间年挣的钱 = [start + 1,end)*当年钱数
    // 开始年挣的钱 = [month-day,12-31]*挣的钱
    // 截止年挣的钱 = [1-1,month-day]*挣的钱
    // 特殊情况：
    // 如果 start == end（不足一年）
    // 如果 start + 1 == end（不足两年）

    //    【1】 2 【3】 4 【5】 6 【7 8】 9 【10】 11 【12】
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int startY = in.nextInt();
            int startM = in.nextInt();
            int startD = in.nextInt();

            int endY = in.nextInt();
            int endM = in.nextInt();
            int endD = in.nextInt();
            // 总钱数
            int totalMoney = 0;
            if (startY == endY) {
                // 不足一年
                System.out.println(getMoneyOfOneYear(startY,startM,startD,endM,endD));
            } else {
                // 大于两年
                int leapYearMoney = getMoneyOfOneYear(2024,1,1,12,31);
                int normalYearMoney = getMoneyOfOneYear(2023,1,1,12,31);
                for (int i = startY+1; i < endY; i++) {
                    if (isLeapYear(i)) {
                        totalMoney += leapYearMoney;
                    } else {
                        totalMoney += normalYearMoney;
                    }
                }
                System.out.println(totalMoney);
                totalMoney += (getMoneyOfOneYear(startY,startM,startD,12,31)
                        + getMoneyOfOneYear(endY,1,1,endM,endD));
                System.out.println(totalMoney);
            }
        }
    }

    /**
     * 根据起止year-month-day，计算同一年中挣的钱
     *
     * @param year
     * @param startM
     * @param startD
     * @param endM
     * @param endD
     * @return
     */
    private static final int[] days = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    private static int getMoneyOfOneYear(int year, int startM, int startD, int endM, int endD) {
        int money = 0;
        if (startM == endM) {
            money += isPrimeNum(startM) ? endD-startD + 1 : 2*(endD - startD + 1);
            return money;
        }
        // 计算开始月挣的钱
        int startDays = days[startM];
        if (startM == 2) {
            startDays += isLeapYear(year)?1:0;
        }
        money += isPrimeNum(startM) ? startDays - startD + 1 : 2*(startDays - startD + 1);
        // 计算结束月挣的钱
        money += isPrimeNum(endM) ? endD : 2*endD;
        // 计算中间月挣的钱
        for (int i = startM + 1; i < endM; i++) {
            switch (i) {
                case 1:
                case 8:
                case 10:
                case 12:
                    money += 62;
                    break;
                // 二月特殊处理
                case 2:
                    money += isLeapYear(year) ? 29 : 28;
                    break;
                case 3:
                case 5:
                case 7:
                    money += 31;
                    break;
                case 4:
                case 6:
                case 9:
                    money += 60;
                    break;
                case 11:
                    money += 30;
                    break;
            }
        }
        return money;
    }

    /**
     * 判断是否是闰年
     *
     * @param year
     * @return
     */
    private static boolean isLeapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }

    /**
     * 判断是否为素数
     *
     * @param n
     * @return
     */
    private static boolean isPrimeNum(int n) {
        if (n == 1) {
            return false;
        }
        if (n == 2) {
            return true;
        }
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] array = new int[100001];
        //构造 1-1000000 之间的斐波那契数组
        array[1] = 1;
        array[2] = 2;
        for (int i = 3; i < 100001; i++) {
            array[i] = (array[i - 1] + array[i - 2]) % 1000000;
        }
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            System.out.printf((n < 25 ?"%d\n" : "%06d\n"),array[n]);//F[25]=121393第一个6位数,因此当n大于等于25时，补齐前面的0

        }
    }


}
